home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Aminet 13
/
Aminet 13 - August 1996.iso
/
Aminet
/
game
/
misc
/
DoopsiDemo.lha
/
Programs.lha
/
Editor
/
Docs
/
ShortManual.edoc
next >
Wrap
Text File
|
1996-06-26
|
42KB
|
1,097 lines
*************
Introduction.
*************
The name of the game.
Doopsi-GS means: Dinamical Object Oriented Programming System Interface -
Game System. We named our program this way for many reasons: Doopsi
remember us of Boopsi, the Object Oriented Intuition System of our beloved
Amiga; it's an Object Oriented program in the tecnical meaning of the word,
that is to say as far as its internal structure is concerned; it's a
Programming Interface because it simplifies the the programming task making
it completely automatic and quick.
This Programming System is very different from other products devoted to
the same scope because it is extremely easy to use, even for people that
has little programming skill: the user draws all the graphics and supplies
all the sounds and musics he needs and then our program puts all things
together. The idea that lies under all the inner workings of this program
is straightforward: you first define the scenes, then put some objects on
them and, at last, you specify how each one of the objects must react when
the guy that is playing acts on it (this is the only coding part you have
to face). Well, to be sincere there are other parts of the work I've not
included in the previous description, but you'll learn them as you get more
involved in Doopsi: for example, one of the tasks you have to deal with is
to build the path along which the Man walks (the Man with the capital
letter is the chief character of the adventure), or another task is to
write the dialogs between the Man and some other object, and so on.
These are the features of Doopsi:
- OS sensitive (it works under V37+).
- completely localizable (it uses our "locator.library" to change
languages, but in future versions we will adapt it to the standard
"locale.library" if we can make it work also under V37).
- AGA compatible.
- the Editor is completely system friendly.
The Doopsi Game System is made of two indipendent programs: the Editor and
the Player. As their names might suggest, the Editor is the one that
builds the adventure, while the Player exploits the datas produced by the
Editor to make you play your game. You have to think to the Editor as
generating some sort of program and to the Player as an interpreter of such
a program: if occurs any runtime error the Player will prompt you with an
error message and, if it can, continue the processing of the game, just as
any interpreter of any language would do (well, actual languages can't
continue after a runtime error, but we are better and we do!).
---------------------------------------------------------------------------
******************************************************
The authors (the most interesting part of the manual):
******************************************************
this is the situation up to 27 - 6 - 1996 (date of first upload):
Andrea has just got a degree in Physics at the University of Milan, and is
now studying to enter a Ph.D. course.
Fabio is working as a Project Manager at DeAgostini MultiMedia, in Milan.
He likes Amigas, cakes, girls, fun, OOP programming and DOOPSI ;)
Our addresses are:
Fabio Rotondo Andrea Galimberti
c.so Vercelli, 9 via Villoresi, 87
28100 Novara 20029 Turbigo (Mi)
Italy Italy
E-Mail: fsoft@intercom.it
Phone: (ITA) - (0)321 - 459676 Phone: (ITA) - (0)331 - 871009
The Web pages are:
http://www.intercom.it/~fsoft/doopsi.html -> DOOPSI Home Page!!!
http://www.intercom.it/~fsoft -> Fabio Soft Home Page
DOOPSI Mailing list:
TO SUBSCRIBE send a mail to
fsoft@intercom.it
With:
SUBSCRIBE DOOPSI your_name@your_email.addr
in the body.
---------------------------------------------------------------------------
****************
Greetings go to:
****************
Mik and Gio of ClassX: for some useful routines. For their support,
for their ideas, for beign them.
Giorgio Fornara: for the great graphics of the Demo that is not
included in this package, but will appear sooner than
possible. He has drawn also the Doopsi logo that
appears on the Editor's screen.
Andrea Rotondo: for the Tutorial graphics.
Stefano Clemente: for beta-testing.
Lele and Paolo of Intercom: for creating DOOPSI - Mailing list.
*******
Hellos:
*******
from Andrea to Laura: for having endured me until now.
from Fabio to his mommy (and also his father).
---------------------------------------------------------------------------
*******************************
LICENSE AGREEMENT FOR DOOPSI-GS
*******************************
I. LICENSE RIGHTS AND RESTRICTIONS
Fabio Rotondo and Andrea Galimberti ("authors") grant you the
non-exclusive, non-assignable right to use enclosed DOOPSI-GS software in
object code form (the "DOOPSI") on a maximum of 1 computer system at one
time. You may not reverse engeneer, decompile, or dissassemble DOOPSI,
except to the extent that the foregoing restriction is expressly prohibited
by applicable law. You may not rent or lease DOOPSI, or otherwise transfer
DOOPSI and accompanying written materials. All rights not expressly
granted are reserved by authors.
II. NO WARRANTIES
DOOPSI and accompanying written materials are provided "as is", without
warranty of any kind. To the maximum extent permitted by law, authors
declaim all warranties, either express or implied, including but not
limited to implied warranties of merchantability, fitness for a particular
purpose and noninfringment. The entire risk arising out of the use or
performance of DOOPSI and any accompanying written materials remains with
you.
III. NO LIABILITY FOR CONSEQUENTIAL DAMGES
To the maximum extent permitted by applicable law: in no event shall the
authors or their suppliers be liable for any damages whatsoever (including,
without limitation, damages for loss of business profits, business
interruption, loss of business information, or other pecuniary loss)
arising out of the use of or inability to use DOOPSI, even if the authors
have been advised of the possibility of such damages. Because some
states/jurisdictions do not allow the exclusion or limitation of liability
for consequential or incidental damages, the above limitation may not apply
to you.
IV. SHARING AND SPREADING
You are authorized in spreading and sharing this document along with all
the rest of the archive, only if the program is a "SHAREWARE" version or it
is a "SPECIAL EDITION". The "SPECIAL EDITION" may not be uploaded to
Aminet or to any BBS and may not appear upon any magazine without the
written permission of the authors. You can, and you are invited to do so,
copy and spread the original DOOPSI SHAREWARE VERSION archive, but you MUST
NOT COPY in any form the DOOPSI REGISTERED VERSION, except for personal
use.
V. MISCELLANEOUS
If you acquired this product in the United States, this Agreement is
governed by the laws of the State of Washington. If you acquired this
product outside the United States, local law may apply. If either party
employs attorneys to enforce any rights arising out of or relating to this
Agreement, the prevailing party shall be entitled to recover reasonable
attorneys fees, costs and expenses.
---------------------------------------------------------------------------
*************
Installation.
*************
There is an Installer script to accomplish this task, but for the ones that
like to do it manually we describe what should be installed and where. (By
the way: to use the script you must have the Installer program and the Lha
utility.)
The three archives have already the final directory structure. You have
first to depack the Programs.lha archive; the latter creates two
directories: one contains the Editor and the other contains the Player.
There's also a third directory in which you find two libraries: the
"locator.library" and the famous "reqtools.library"; you have to copy these
libraries to your Libs: directory. The final step consists in making the
following assignment: Assign Doopsi: to the Editor directory.
The default language is english, but are supplied also the catalogs to
install the italian language: you just have to extract the Catalogs.lha in
the same directory where you put the Editor drawer (not IN the Editor
drawer, but NEXT to such a drawer). This creates a Catalogs directory in
the Editor directory and also adds the file "player.catalog" in the
Player/Data drawer.
Then you have to depack the Tutorial.lha archive to the Same directory
where you put the Editor drawer (not IN the Editor drawer, but NEXT to such
a drawer): this will create a directory Tutorial in the Editor drawer,
where you can find some graphical datas to start immediately.
The resulting directory structure is:
Editor
|
+---Catalogs
|
+---Docs
|
+---palettes
|
`---Tutorial
|
+---Objects
|
+---Berny
|
+---Scenes
|
`---Sounds
Player
|
`---Data
The Editor Must find in its directory the file "doopsi.dat". The Catalogs
directory is needed only if want to use a language different from english
(up to now only the italian catalogs are supplied): you copy in this
drawer only the catalogs of your favourite language and leave out all the
others.
The Player Must find a subdirectory (of its own directory) named "Data"
with the following files: "player.dat" and "panel.iff". The "panel.iff"
is the console image you can change (see the Appendix B). The
"player.catalog" file is needed only if you want to use a language
different from english, otherwise you can throw it away.
The catalogs' sources will be supplied (if wanted), with the executables
used to create them, in a separate package.
IMPORTANT NOTE: The Editor needs the Doopsi: assignment, but the Player
has been built in such a way to be completely relocable (no assignments
needed). When you start the Player from a Shell you just have to make the
Player directory the current one and then call the program: the Player
searches then in the current directory for a subdirectory named "Data",
where it Must find the files "player.dat" and "panel.iff". If, instead,
you start the Player from the Workbench, it is unable to find the current
directory (sorry, we'll fix this sooner than possible) and searches for the
subdirectory "Data" in the Sys: drawer.
The commandline to start the Player is: Player Doopsi_file_name. If you
forget to give a filename, the Player will open a file requester and asks
you to select a file.
---------------------------------------------------------------------------
****************
The Main window.
****************
The story begins from here.
First of all, let's describe the window contents. The topmost part is
divided in two sections: the left one is related to scenes, while the
right one is dedicated to objects. Then there comes a row with
miscellaneous editors and, last but not least, the final row contains
gadgets devoted to load and save your work as a whole.
Let's start with the scene section. To create a new scene you have to
press the "New" button. To select the scene to work with, you have to use
the "List" gadget.
The remaining gadgets all open new editors. The "Attrs" one is for
entering the Screen Attributes editor, where you can change some features
of your scene; the "Spot editor" button calls the Spot Editor to put Spots
on the scene; the "Path editor" gadget enters the Path Editor used to edit
the path on which your Man is supposed to walk.
The "New" gadget creates a new object and opens the Object Attributes
editor to allow the user to edit such an object. The "List" gadget
displays the list of all objects created up to now.
The "Attrib" gadget opens the Object Attributes editor; the "Doopsi code"
button enters the Doopsi Coder used to specify what the Player should do
when the user acts on an object; the "Anim Editor" gadget calls the Anim
Editor that allows you to convert an object to an AnimObject by building an
animation from its images.
The next section contains three buttons: the "Prefs" one enters the
Preferences editor where you can change for example some names the Player
uses as defaults, or your favourite paths, and so on; the "Dialog Editor"
calls the Dialog Editor used to create dialogs between your Man and any
other character of your story; the "Info" gadget tells you how many objects
and scenes you created up to now and the amount of free memory.
Now we describe the last row. The "Save All" gadget is for saving all the
adventure. The "Save Final" button differs from the "Save All" gadget
because the file saved will be encrypted. The "Load All" gadget allows you
to load a file saved with the "Save All" or the "Save Final" gadget.
Some notes on how the Player finds the Man.
This problem arises because the Man is an AnimObject (actually four
objects: one for each direction) like all the other AnimObjects you may
link to your game. Thus the Player has to know which objects represent the
chief character of the story. The Man's internal name is composed of a
root name (the default one is "Man") and an extension indicating the
direction (e.g.: U for up, D for down, etc.): so the AnimObject
containing the animation representing the Man walking right may be called
(internal name always!) "ManR", and so on. You need also other four
AnimObjects representing the Man speaking in the four directions: the name
of such AnimObjects is built from the root name, adding to it a first
extension (the default is "Talk") and the second extension is the direction
as before. So the tipical name of an AnimObject showing the Man speaking
to the left is "ManTalkL".
You can choose your favourite root and extensions by writing them in the
preferences editor.
---------------------------------------------------------------------------
***********
PATH EDITOR
***********
INTRODUCTION
Path Editor helps adventure creator to develope paths on which players will
move. Paths creation is probably one of the more complex things and
requires some attention. The path created upon a scene will limit players'
movements during the game. This must take the creator to an accurate
planning for the creation of the path.
PATH THEORY
Path is structured in nodes, stop units. Every node can be some special
features that allows better control of player's movements in the scene, but
we'll talk later about these features. Every node has some branches (max.
7 per every branch) that allows links with other nodes.
Path sets, using nodes, player's freedom of movements. A path is so build
up by nodes, linked each other with branches, so to create a sort of "web".
Player's movements on the scene will apply on this "web", as nodes and
branches were a sort of "invisible railroad" on which player will move.
Warning: player's movements on a scene are binded ABSOLUTELY to the scene.
It is not possible in any way to allow player to move somewhere else than
path's extension. If you'll ask to the player to reach a point out of
path's limits, the player will reach the nearest point to the one selected.
This aspect of the path could be seen as a limit, but it is one of the
greatest features, which will allow a great flexibility in game-designing:
for example, it is possible to create a scene that encloses more paths and
"to forbid" certain areas until a particular condition happens.
With a bit of practice, you'll certainly design complex and various paths.
Path Editor will trustly follow you step by step in this task.
Happy working.
NOTE: following tutorials presume you already know other features of
DOOPSI, such as scene creation, anim creation using Anim WorkShop and
object handling with Object Attributes.
TUTORIAL 1 - A Simple Path
In this tutorial we'll learn to draw a little path of four nothes and to
link these nodes each other with very simple diramations. Goal of this
tutorial is to get you used to Path Editor's basic commands. You'll learn
to add and delete nodes, to add branches and to force redrawing of the
scene (needed in some occasions). In the next one, we'll talk about more
complex arguments. Execute this tutorial more than one time, until you'll
be sure you have complete knowledge of the commands.
To follow this tutorial, you must have already created a scene called
"tutorial_room1".
Press Path Editor in DOOPSI main panel.
Do not be afraid for the great number of buttons, as time goes by, you'll
perferctly know them.
First of all, it is better to place all nodes on the screen. Naturally,
you can add some of them later, but in this way you'll be certain to cover
all important locations.
To add a node on the scene, you just have to do these steps:
- Press "Add Node(s)"
From now on, until you choose to stop, every mouse click on the
scene will generate a new node.
- Create four nodes, as they were formin a box.
- Press "Add Branch(es)" to add branches.
From now on, until you choose to stop, you'll be able to add
branches among nodes.
- Press on the first node (it will change colour)
- Press on the second node (it will change colour and a straight line
will link these two nodes)
We have just created the first link. To create another one, follow
these steps:
- Press on the second node (it will change colour)
- Press on the third node (it will change colour and a strainght line
will link these two nodes)
Follow these steps to link each node to the next, creating a box.
Now you have created these nodes, you can test the movements that the
player will be able to do during the adventure:
- press the button "Try Movements" and select starting node
(for example, the first). Node will change colour.
- Select the second node (for example, the third). Node will change
colour.
Program will try to compute the path between two selected nodes and will
show it, step by step, highlighting nodes. If you have selected the first
and the third and you have linked how we described in the example, you
should see highlight nodes one, two and three. Naturallym this is a quite
simple example, but the chance of testing path is very useful in complex
scenes.
Now create a new node where you want and link to it other nodes, following
previously described steps. Try again to use the "Try Movements".
Before end this tutorial, let's try to delete a node from the scene:
- Press "Kill Node"
- Select node you wish to remove.
- Node will be erased.
At this point, some graphics on the scene could be damaged and that the
node you have just erased seems to be still there. This is not a DOOPSI
problem, but you need to refresh completely the graphic. Press "Redraw
All" to update the graphic, you'll see that now the deleted node will not
appear anymore.
---------------------------------------------------------------------------
****************
The Spot editor.
****************
This allows you to put "Spots" on the scene: they are simply little
crosses with two coordinates and a name. You use this name to address a
particular spot and Doopsi will use its coordinates.
Here is a TUTORIAL:
- Create a new scene (using the "New" gadget in the scene section of the
main editor window).
- Enter the Spot editor.
- Click on the "Add Spot" gadget: a message will appear saying "Add mode
enabled".
- Click on the scene where you want to put a spot: you can repeat this
last operation until you have positioned all your spots.
- Click again on the "Add Spot" gadget to disable the Add mode.
- Click on your scene to select a spot: a message will appear saying "Get
Info"
- You can modify the currently selected spot name by just writing it in the
string gadget "Spot Name" and pressing Return.
- Quit the Spot editor.
---------------------------------------------------------------------------
****************************
The Screen attibutes editor.
****************************
This editor allows you to change the name of the current scene, to load
a different background without removing objects, path and spots you have
already linked to that scene, and other useful things...
The bottom row says something like this: "Use Action Open of Object foo".
In other words the Doopsi code contained in the specified action of the
selected object will be executed every time you enter the scene during the
game. To switch off this option you have to clear the object's name in the
string gadget.
---------------------------------------------------------------------------
*****************************
The Object Attributes Editor.
*****************************
This editor allows you to specify an object characteristics and to put it
on the scene.
A first tutorial: "the little sheet of paper".
- I suppose you already loaded a scene to put objects on it. Now create a
new object by pressing the "New" gadget in the object section of the main
window.
- Enter the Object Attributes editor.
- In the "Name" string gadget enter "the paper".
- Click on the "Internal Name" string gadget and write "paper".
- Click on the cycle gadget to select the "Graphic" object type because our
object is going to be drawn on the scene.
- Press the "Add" button and, using the file requester, choose the "paper"
image in the Tutorial directory. Now the image is linked to the object.
- Eventually press the "Pos" button to position the object on the scene.
- You can move the object to its final location by selecting it with the
mouse and dragging it around the scene.
A second tutorial: "an empty zone".
- Create a new object just as in the previous tutorial.
- Enter its name and (more important) internal name.
- Click on the cycle gadget to select the "Empty" object type: our object
will be an empty frame (not drawn on the scene during the game).
- Press the "Set Zone" button: a rectangle will appear on the scene.
- Drag the rectangle around the scene with the mouse and scale it using the
gagdet in the lower right corner of the rectangle itself.
- When you're done, click on the "Pos" gadget to link this object to the
scene.
---------------------------------------------------------------------------
*****************
The Doopsi Coder.
*****************
Introduction
The Doopsi Coder is the editor that allows you to "program" the objects to
react to the user's actions. As far as the Doopsi Player is concerned,
objects are only complex data structures without a precise meaning: the
task of the Coder is to coordinate the user's actions with the behaviour of
every object. The Coder is probably the most important part in the editing
of an adventure, because it allows the user to give a "real" appearance to
the objects on the scene and allows the player to interact with such
objects.
Note: the following tutorials suppose that you already know something
about Doopsi, like the Object Attributes editor. We refer the reader to
the chapter related to such an editor to revise how to create and edit a
new object.
Tutorial 1 - "A door that open and close"
To use this example you are supposed to have created an object called
(internal name) "door" with two shapes linked to it, the first representing
the door closed ("door_closed") and the second representing the door open
("door_open").
- From the main window make the "door" the current object and enter the
Doopsi coder.
- Press the "Open" button to code the object reaction to the action "Open".
Now execute the following steps:
- Instruction "IfStatus"
- Select the "door" object
- Insert 0 when you are asked for a value
(in the Coder window will appear the line: IfStatus SELF, 00)
- Instruction "ChangeStatus"
- Select the "door" object
- Insert the value 1
(in the Coder window will appear the line: ChangeStatus SELF, 01)
- Instruction "ChangeShape"
- Select the "door" object
- Select the name of the shape representing the door open
(in the Coder window will appear the line: ChangeShape SELF, 01)
- Instruction "Else"
- Instruction "ShowText"
- When asked for a string enter: "The Door is already open"
(in the Coder window will appear the line: ShowText The Door is already
open)
At the end of the previous steps you should have in the Coder's window the
following code:
IfStatus SELF, 00
ChangeStatus SELF, 01
ChangeShape SELF, 01
Else
ShowText The door is already open
EndIf
This means (line by line):
If the status of the object itself (SELF -> "door") is 0
Change the status of the object itself (SELF) to 1
Change the shape of the object itself (SELF) to 1 (the door open)
Else
Show the message "The door is already open"
End of the If group
Now we are going to write the code relative to the "Close" action. Press
the "Close" button to code such an action, and execute the following steps:
- Instruction "IfStatus"
- Select the "door" object
- Insert the value 1
- Instruction "ChangeStatus"
- Select the "door" object
- Insert the value 0
- Instruction "ChangeShape"
- Select the "door" object
- Select the name of the shape representing the door closed
- Instruction "Else"
- Instruction "ShowText"
- Enter "The door is already closed"
- Instruction "EndIf"
The following code will appear:
IfStatus SELF, 01
ChangeStatus SELF, 00
ChangeShape SELF, 00
Else
ShowText The door is already closed
EndIf
"Translated" into everyday words this means:
If the status of the object itself (SELF -> "door") is 1
Change the status of the object itself (SELF) to 0
Change the shape of the object itself (SELF) to 0 (the door closed)
Else
Show the message "The door is already closed"
At this stage the coding of the "door" object is completed. You can press
the Ok button to quit the Coder and return to the main window.
---------------------------------------------------------------------------
*****************
The AnimWorkshop.
*****************
This editor allows you to build animations putting together some shapes in
a sequence. The result is that you change an Object in a more complex
thing called an "AnimObject", that is to say an object containing an
animation. Such an animation will be played when the AnimObject is blitted
on the scene.
Let's start with a quick tutorial: "putting together a pendulum"
- Create a new object with "Pendulum" as internal name.
- Enter AnimWorkshop.
- Select the "Load Frames" gadget and, using the file requester, select the
shape named "pendulum.000". AnimWorkshop will then load the three shapes
called "pendulum.000", "pendulum.001" and "pendulum.002".
- Select frame number 0 and click on the "Add Frame" gadget; select frame
number 1 and click on the "Add Frame" gadget; repeat again for the third
and last frame.
- Now enter 3 in the "Frame Rate" string gadget.
- Press "Play" to view the animation and the right mouse button to stop it.
- Press the "Ok" gadget to exit AnimWorkshop.
Here's a more difficul tutorial on "how to build the Man":
- First create a new object using the Object Attributes Editor (I suppose
you already know how to do this) and call it (internal name) "ManRight".
Now you are ready to enter AnimWorkshop.
- Select the "Load Frames" gadget and, using the file requester, select the
shape called "man_walk_right.000": AnimWorkshop will load this frame and
all subsequent frames with the same name and increasing number; such frames
will be displayed on a new screen. You can cycle through them using the
"Prev" and "Next" gadgets in the upper part of the editor window.
- Select frame number 1 (frame 0 is the rest frame and we will consider it
later) and click on the "Add Frame" gadget: the number 1 will appear in
the Sequence window. Then move to frame number 2 and click again on Add
Frame; repeat these actions until the last frame is added.
- Now you can enter the frame rate in the "Frame Rate" string gadget:
write 12 and press Return.
- Well, your animation is ok: press on the "Play" gadget to look at it.
- Stop the animation by pressing the right mouse button. Then, exit
AnimWorkshop by pressing either the "Ok" or the "Cancel" button depending
on whether you are satisfied of your animation or not.
- What about frame number 0? It cannot be included in the animation
because it is the rest frame, but the Player has to know which frame to use
when the Man is still: so we link it to our Man object and point to it by
the "Default Shape" field in the Attributes editor. (Obviously this field
has no meaning for a general animation.)
---------------------------------------------------------------------------
*************
DIALOG EDITOR
*************
INTRODUCTION
In every good adventure, dialogs between characters have to be present.
Better dialogs are, brighter conversations, more funny is the adventure.
To create dialogs is not an easy task: you have to consider a lot of
elements and foresee a different answer for every possible phrase. That's
why we strongly suggest to plan your dialogs and to track on a sheet of
paper real flow charts where "to see" dialogs' structure.
Dialogs, in DOOPSI, can be structured in a handy and powerful way and it
is possible to write dialogs calling other dialogs or jumping from one part
to the other to get back later.
Dialog Editor is a easy and functional tool that will allow you to create
complex dialogs in a minute: be carefull, anyway, because, as we have
already said before, not planning the dialog, you'll risk to get lost...
to loose, just to say, the dialog's path.
WHAT IS A DIALOG
In DOOPSI, a Dialog is composed by a sequence of "pages". As in all
others DOOPSI elements, even Dialog's pages have their "internal name" that
identify them.
A page is made by an "answer", which is the phrase that the talker will
say to our player and one or more phrases user selectable as "answer" to
the "answer"... hmmm, said in this way, it may seem to be confused, let's
try to explain better, with an example: let's start with the tutorial.
TUTORIAL 1 - A Breef Dialog
To enter into the Dialog Editor, simply press "Dialog Editor" button in the
Main Window. At this point you'll see the Dialog Editor which will allow
you to create the dialog.
1 - Press the "New" button to create a new dialog page.
A string request will pop up asking for the page's internal name.
We want this page to be the starting point, so write "Start_Dialog".
Now you can start to write dialog phrases.
2 - Press the "Add" button (bottom left) to add a new phrase. The "New
Phrase" string will appear in the string gadget called "Phrase:".
Delete "New Phrase" and insert: "Hello! How are you?"
3 - Repeat step 2, inserting these messages: "How are you!" and
"I should go now".
4 - Now we have to create a segond page, press "New" and place
"How_Are_You" as internal name, se we'll remember this page is
the answer to the "Hello, how are you?" question.
5 - In the "Answer:" gadget (top of the window), write "Well!",
this is the answer that our friend will give us.
To write something inside this field is not stricly wanted, but
it is always better that the other says something... otherwise
our Dialog could become a "monologue".
The only solution in which we should omit an answer is in the first
dialog's page, when we begin to talk with someone.
6 - Now repeat setp 2, and write "Now I go, bye".
7 - Now we have to "link" these two pages together.
To do so, return to the first page. Press the "Select" gadget:
a Lister containing dialog pages' names will appear. In our case
there'll be two names: "Start_Dialog" and "How_Are_You", select
"Start_Dialog".
Dialog Editor's window will show the first page again.
8 - Now press on the phrase, "Hello, how are you?" that will appear in
the string gadget (if you wish, you should also edit the phrase)
and then select the "Jump" button, the same Lister we have seen
previously will appear again, this time select "How_Are_You"
phrase: the page's name will appear in the string gadget "Jump:".
That's all! Now, when, during the game, user will select phrase
"Hello! How are you?" the other will say "Well!".
Is that easy, isn't it?
9 - Just for fun, we'll link also the "How Are You!" phrase to
"How_Are_You" page. Press "How are you!" and then on "Jump" and
select "How_Are_You".
NOTE: a phrase without a jump means "END OF DIALOG". When the user will
select one of these phrases, the Dialog ends.
In our example, we have two phrases of this kind: the first is
"I should go now" and the other is "Now I go, bye".
NOTE2: as a convention, the exiting phrase is the last in the list.
Where possible, please keep this convention.
---------------------------------------------------------------------------
***********
PREFERENCES
***********
DOOPSI is a complex and flexible program and some of its features can be
adapted to programmer's needs. In DOOPSI, modifications apply by
Preferences window, divided in four parts.
Path Selection.
In this section it is possible to choose dirs containing all files of a
specific kind. Creating complex adventures, it is better to divide
graphics, sound and all the rest in different dirs. With these paths,
every time a file requester will appear (for example to load a background)
the directory will be set to the preferences' one. In case you do not want
any default dir, just plase an empty string in the string requester.
Next to the string gadget there is a gadget called "R" (research), which
will open a path requester you can use to search the directory you want to
set as default.
Palette Editing
In this section it is possible to load, edit and save DOOPSI's colors.
By pressing "Load" you'll be able to load up the first four colors of any
IFF pic, with "Save" you can save the palette and with "Edit" you will be
prompted to a standard Palette Requester which allows you to directly edit
colors.
Setting Default Names
This is the most important secion of the preferences window.
As you should already know, DOOPSI uses for the adventurer some default
names, needed to the Player to use the right animations when needed. Just
to fresh your mind, suggesting to go to read again the complete Player
documentation, here there are default names:
NAME DEF. VALUE DESCRIPTION
Root Man It is the root name, which defines game player's
anims.
Left L These four vals set animations of player
Right R in all the four directions. For example
Up U ManU is "Man Up", that is: "animation of the
Down D man walking forward".
Talk Talk This is a kind of "second root" and it is the
suffix that is added DIRECTLY to the real root
to define anim of player while it speaks.
To this new root, the usual suffix Left, Right,
Up or Down. For ex. player speaking to the
left is so defined: ManTalkL.
These names, being just for "internal" use of the Player, should remain
"rigid" and not modifiable, but we preferred to allow modification, to let
everything be more readable. Infact, you can change these names, giving
them a more exaustive meaning. Here there is an example.
Root = Man
Talk = _talking
L = _left
R = _right
the old ManTalkL become: "Man_talking_Left", more elegant. Be careful,
anyway: in DOOPSI internal name are fixed to 20 char length.
Starting Scene
With this last part of Preferences' window, you can define the name of
the first scene that will be shown at the beginning of the adventure.
"USE/LOAD/SAVE/CANCEL" Gadgets
These gadgets allows you to do the following things: "USE" to use the
current configuration, "LOAD" and "SAVE" to load a previous saved
configuration and to save the current one, and "CANCEL" to abort settings.
Note
Preferences are ALWAYS saved with the complete DOOPSI file, to allow
handling of different adventures at the same time with different settings.
---------------------------------------------------------------------------
*********************************
Appendix A: Doopsi instructions.
*********************************
In the following list, objects and scenes are identified by their internal
names, so Object represents the Object internal name, and so on.
Here is the description of only a limited number of instructions:
registered users will get the complete documentation.
ChangeDescription Object, Text
Changes the name field of the selected Object to Text. This name is the
one that appears on the console display line when the object is selected on
the scene.
ChangeScene Scene
If Scene has been found, this instruction exits the current scene and
displays the new scene.
ChangeShape Object, Shape
Changes the current shape of the selected Object.
ChangeStatus Object, Value
Puts Value in the status field of the selected Object.
IfOnScene Object
Returns True if Object is blitted on the scene.
IfSceneIs Scene
Returns True if Man is currently in scene Scene.
IfStatus Object, Status
Returns True if the status field of the selected object is equal to Status.
InvToScene Object
Picks up the selected Object from the inventory and puts it on the scene at
the internal coordinates of Object: such coordinates are initialized when
the Object is positioned on the scene using the Editor. If Object is an
AnimObject then the animation will be automatically played.
MoveObject Object, Spot
Moves Object from its current position on the scene to the location
specified by Spot position. During the movement an AnimObject is
substituted to the Object current shape if it has been previously specified
with the SetMoveAnim instruction.
MusicPlay File
Starts playing the contents of File. File must be a standard tracker
module.
Open Object
Close Object
Look Object
Take Object
Drop Object
Push Object
Pull Object
Talk Object
Use Object
These instructions execute the Doopsi code contained in the corresponding
action of Object. They are treated just like subprograms, and you can nest
at most 10 of such subprograms.
PutObject Object, Spot
Blits Object at the Spot location. Object may be also an EmptyZone.
SceneToInv Object
Picks up the selected Object from the scene and puts it in the inventory.
If Object is an AnimObject the animation will be automatically stopped.
SetManName Object
This instruction is used to change the Man's animations: the root name
(that is to say, after having removed any extension) of Object is used to
build the Man's names until SetManName is called again or it is issued by a
path node.
ShowAnim AnimObject
This instruction plays the animation contained in AnimObject. The
animation will be displayed at the internal coordinates of AnimObject. The
number of animations the Player can handle at the same time is limited.
ShowDialog Dialog
This starts a conversation between the Man and the currently selected
object. Dialog is the first page of the conversation. If the animation
showing the Man talking is found then it is played; you can choose an
animation showing Object talking with SetTalkAnim. The Man text colour and
the object text colour are selected using calls to ManTalkColour and
ObjTalkColour respectively.
ShowText Text
Displays Text. The position and line breaks will be determined by the
Man's position in the scene and by the width of the scene itself. The
Man's direction determines which one of four animations will be played, if
it is found, to make the Man speak; if the animation is not present the
Player won't complain and it only leaves the Man still. The colour of the
text is selected using the ManTalkColour instruction. The user has to
click once on the left mouse button to quit the text.
SoundPlay File
Plays the contents of File. File must be a standard Iff 8SVX sample.
---------------------------------------------------------------------------
*************************
Appendix B: The console.
*************************
The console is contained in the file "panel.iff".
The console+disk screen must be a lowres non interlaced screen and the user
can paint everything he likes on it, but he must remember to observe the
dimensions of the sensing zones.
---------------------------------------------------------------------------
***********
The Player.
***********
The startup sequence.
When the Player starts it searches, before anything else, for the console
(the bottom half of the screen where the buttons and the inventory stay)
and the file "player.dat". Then it looks for the Doopsi main file and,
from this time on, all the actions are determined by the data it finds in
such a file. If it doesn't find anyone of the above mentioned pieces then
it complains and quits.